Inscoper¶

Classes¶

	Name
class	Inscoper::AbstractSubDevice AbstractSubDevice class implements custom sub-devices.
class	Inscoper::AbstractSystem AbstractSystem class is the base class for all device types.
class	Inscoper::AdvancedConnectionConfig AdvancedConnectionConfig class provides required information for most connections: Analog, TTL, PWM, RS232/UART.
class	Inscoper::Bridge The Bridge class is the main class of The Inscoper API.
class	Inscoper::Camera Camera class defines the interface for camera devices.
class	Inscoper::ChildStatusParam ChildStatusParam class represents a dependent status parameter.
class	Inscoper::Config Config class provides information for global configuration.
class	Inscoper::ConnectionConfig Base class for connection configuration.
class	Inscoper::ConnectionDescription ConnectionDescription class provides connection information coming from the device controller.
class	Inscoper::Constraint Constraint class defines limits and valid values for a parameter.
class	Inscoper::CurrentStatusAction CurrentStatusAction class allows executing code after status updates.
class	Inscoper::CustomDriverConfig CustomDriverConfig class provides information for custom devices.
class	Inscoper::CustomDriverDescription CustomDriverDescription class provides information for custom drivers.
class	Inscoper::DeviceConfig DeviceConfig class provides information for device configuration.
class	Inscoper::DeviceDescription DeviceDescription class provides device information coming from drivers.
class	Inscoper::DiagResults DiagResults class contains the results from a device diagnostic.
class	Inscoper::Dimension Dimension class manages the parameters of a dimension (within a multi-dimensional acquisition).
class	Inscoper::DimensionParam DimensionParam class holds status parameters for a dimension.
class	Inscoper::DriverConfig Base class for driver configuration.
class	Inscoper::DriverDescription DriverDescription base class.
class	Inscoper::ErrorListener ErrorListener class allows receiving errors.
class	Inscoper::EthernetConnectionConfig EthernetConnectionConfig class provides required information for Ethernet devices configuration.
class	Inscoper::ExternalDriverDescription ExternalDriverDescription class for external device drivers.
class	Inscoper::FunctionDescription FunctionDescription class provides function information coming from drivers.
class	Inscoper::FunctionListener FunctionListener class allows receiving notifications when a function is executed.
class	Inscoper::Image Image class represents an image with associated metadata.
class	Inscoper::ImageListener Interface for receiving images during acquisition.
class	Inscoper::InscoperBoxDriverConfig InscoperBoxDriverConfig class provides information for devices controlled by the device controller.
class	Inscoper::InscoperBoxDriverDescription The InscoperBoxDriverDescription class provides information for devices supported by the device controller.
class	Inscoper::InscoperException InscoperException class is the custom exception class.
class	Inscoper::LogListener Interface for receiving log messages.
class	Inscoper::Metadata Metadata class represents a container for image metadata.
class	Inscoper::MicroManagerDriverConfig MicroManagerDriverConfig class provides information for Micro-Manager devices.
class	Inscoper::MicroManagerDriverDescription MicroManagerDriverDescription class provides information for Micro-Manager drivers.
class	Inscoper::ModifiableStatusParam ModifiableStatusParam class represents a status parameter that can be modified during a sequence execution.
class	Inscoper::ParamConfig ParamConfig class provides required information for parameter configuration.
class	Inscoper::ParamDescription ParamDescription class provides parameter information coming from drivers.
class	Inscoper::ParentStatusParam ParentStatusParam class is a specialized StatusParam that allows hierarchical relationships.
class	Inscoper::Recipe Recipe class represents the protocol to create a sequence of operations.
class	Inscoper::RecipeElement RecipeElement class is the abstract base class for all recipe elements.
class	Inscoper::RecipeElementEvent RecipeElementEvent class represents the check of an event within a recipe.
class	Inscoper::RecipeElementGroup RecipeElementGroup class represents a recipe element that holds other recipe elements.
class	Inscoper::RecipeElementSimple RecipeElementSimple class represents a basic recipe step with actions and conditions.
class	Inscoper::RoiCrop RoiCrop class defines a Region Of Interest for cropping.
class	Inscoper::SequenceHandler SequenceHandler class manages sequence preparation progress and cancellation.
class	Inscoper::SequenceListener SequenceListener class provides sequence completion notifications.
class	Inscoper::Shutter Shutter class defines the interface for shutter devices.
class	Inscoper::Stage Stage class defines the interface for 1D-positioning devices.
class	Inscoper::Status Status class represents a state of the system.
class	Inscoper::StatusParam StatusParam class pairs a sub-device with a value.
class	Inscoper::SubDeviceConfig SubDeviceConfig class provides required information for sub-device configuration.
class	Inscoper::SubDeviceDescription SubDeviceDescription class provides sub-device information coming from drivers.
class	Inscoper::SubDeviceId SubDeviceId class uniquely identifies a sub-device.
class	Inscoper::USBConnectionConfig USBConnectionConfig class provides required information for USB devices configuration.
class	Inscoper::UsbInfo UsbInfo class contains all USB devices information connected to the device controller.
class	Inscoper::Utils Utils class provides utility functions.
class	Inscoper::ValueCondition ValueCondition class defines a condition based on a sub-device value.
class	Inscoper::XMLAttribute XMLAttribute class represents an attribute of an XML node.
class	Inscoper::XMLDocument XMLDocument class represents an entire XML document.
class	Inscoper::XMLNode XMLNode class represents a node in an XML document.
class	Inscoper::XYStage XYStage class defines the interface for 2D-positioning devices.

Types¶

	Name
enum class	EBoxType { S_BOX, M_BOX, L_BOX, XL_BOX, UNKNOWN} EBoxType enum defines the device controller types.
enum class	EConnectionType { ADVANCED_CONNECTION, USB_CONNECTION, ETHERNET_CONNECTION} EConnectionType enum defines the types of device connections.
enum	EConnectorType { NONE = 0x0000000000000000, UART = 0x0000000000000001, USB_DEV = 0x0000000000000002, AOUT = 0x0000000000000004, TTL_IN = 0x0000000000000008, TTL_OUT = 0x0000000000000010, PWM = 0x0000000000000020, AIN = 0x0000000000000040, RJ45 = 0x0000000000000080, ILDA = 0x0000000000000800} EConnectorType enum defines specific connector interfaces.
enum class	EConnectionTypeDesc { NONE = EConnectorType::NONE, UART = EConnectorType::UART, USB_DEV = EConnectorType::USB_DEV, AOUT = EConnectorType::AOUT, TTL_IN = EConnectorType::TTL_IN, TTL_OUT = EConnectorType::TTL_OUT, PWM = EConnectorType::PWM, AIN = EConnectorType::AIN, RJ45 = EConnectorType::RJ45, USB_SERIAL_DRIVER = 0x0000000000000100, USB_GENERIC_DRIVER = 0x0000000000000200, USB_HID_DRIVER = 0x0000000000000400, ILDA = EConnectorType::ILDA, USB_SERIAL = (USB_SERIAL_DRIVER
enum class	ESubDeviceType { NONE = 0, INIT, FINISH, DIAG, USB_CHECK, X_AXIS, Y_AXIS, MOVE_AXIS, FOCUS, SHUTTER, OBJECTIVE, CUBE, FILTER_WHEEL, TRIG_EDGE, TRIG_LEVEL, CAM_CHECK_READY, MAGNIFICATION, PROPERTY, CAM_START_CONTINUOUS, CAM_START, CAM_STOP, CAM_SNAP, CAM_SOFTWARE_TRIG} ESubDeviceType enum defines types of sub-devices.
enum class	EDeviceType { GENERIC = 0, CAMERA, XY_STAGE, STAGE, SHUTTER} The EDeviceType enum defines the type of devices, among Micro-Manager and custom devices.
enum class	EFunctionType { SET, GET, CHECK} EFunctionType enum defines the types of operations for sub-device functions.
enum class	EParamType { UINT8, INT8, UINT16, INT16, UINT32, INT32, FLOAT, DOUBLE, UINT64, INT64, STRING, RAW} EParamType enum defines data types.
enum class	EFunctionStatus { AVAILABLE, UNAVAILABLE, UNKNOWN} EFunctionStatus enum defines the status of a function.
enum class	ESubDeviceStatus { UNKNOWN, AVAILABLE, UNAVAILABLE, PARTIALLY_AVAILABLE} ESubDeviceStatus enum defines the state of a sub-device.
enum class	EDriverType { MICRO_MANAGER = 0, INSCOPER_BOX, CUSTOM_DRIVER, NONE} EDriverType enum defines the driver type.
enum class	EPixelType { GREY_8_BITS, GREY_11_BITS, GREY_12_BITS, GREY_14_BITS, GREY_16_BITS, GREY_32_BITS, GREY_FLOAT_32_BITS, GREY_FLOAT_64_BITS, RGB_8_BITS, BGR_8_BITS, RGB_16_BITS, BGR_16_BITS, UNKNOWN} EPixelType enum defines the pixel formats.
enum class	ERecipeElementType { SIMPLE, GROUP, EVENT} ERecipeElementType enum defines the types of recipe elements.
enum class	ESequencePreparationStatus { CREATING, LOADING, CANCELLED} ESequencePreparationStatus enum defines the progress state of a sequence preparation.
enum class	EOperation { OFFSET, MULTIPLICATION} EOperation enum defines mathematical operations for child status parameters.
enum	ELogLevel { LOG_ALL = 0, LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR, LOG_FATAL, LOG_OFF} ELogLevel enum defines the severity levels for logging.
enum	ELogMode { FILE = 0x01, CONSOLE = 0x02, LISTENER = 0x04, ALL = FILE
typedef std::shared_ptr< AdvancedConnectionConfig >	AdvancedConnectionConfigPtr
typedef std::shared_ptr< Config >	ConfigPtr
typedef std::shared_ptr< ConnectionConfig >	ConnectionConfigPtr
typedef std::shared_ptr< CustomDriverConfig >	CustomDriverConfigPtr
typedef std::shared_ptr< DeviceConfig >	DeviceConfigPtr
typedef std::shared_ptr< DriverConfig >	DriverConfigPtr
typedef std::shared_ptr< EthernetConnectionConfig >	EthernetConnectionConfigPtr
typedef std::shared_ptr< InscoperBoxDriverConfig >	InscoperBoxDriverConfigPtr
typedef std::shared_ptr< MicroManagerDriverConfig >	MicroManagerDriverConfigPtr
typedef std::shared_ptr< ParamConfig >	ParamConfigPtr
typedef std::shared_ptr< SubDeviceConfig >	SubDeviceConfigPtr
typedef std::shared_ptr< USBConnectionConfig >	USBConnectionConfigPtr
typedef std::shared_ptr< ConnectionDescription >	ConnectionDescriptionPtr
typedef std::shared_ptr< CustomDriverDescription >	CustomDriverDescriptionPtr
typedef std::shared_ptr< DeviceDescription >	DeviceDescriptionPtr
typedef std::shared_ptr< DriverDescription >	DriverDescriptionPtr
typedef std::shared_ptr< ExternalDriverDescription >	ExternalDriverDescriptionPtr
typedef std::shared_ptr< FunctionDescription >	FunctionDescriptionPtr
typedef std::shared_ptr< InscoperBoxDriverDescription >	InscoperBoxDriverDescriptionPtr
typedef std::shared_ptr< MicroManagerDriverDescription >	MicroManagerDriverDescriptionPtr
typedef std::shared_ptr< ParamDescription >	ParamDescriptionPtr
typedef std::shared_ptr< SubDeviceDescription >	SubDeviceDescriptionPtr
typedef std::shared_ptr< AbstractSystem >	SystemPtr
typedef std::shared_ptr< Camera >	CameraPtr
typedef std::shared_ptr< Shutter >	ShutterPtr
typedef std::shared_ptr< Stage >	StagePtr
typedef std::shared_ptr< XYStage >	XYStagePtr
typedef std::shared_ptr< Constraint >	ConstraintPtr
typedef std::shared_ptr< DiagResults >	DiagResultsPtr
typedef std::shared_ptr< Dimension >	DimensionPtr
typedef std::shared_ptr< DimensionParam >	DimensionParamPtr
typedef std::shared_ptr< Image >	ImagePtr
typedef std::shared_ptr< Metadata >	MetadataPtr
typedef std::shared_ptr< Recipe >	RecipePtr
typedef std::shared_ptr< RecipeElement >	RecipeElementPtr
typedef std::shared_ptr< RecipeElementEvent >	RecipeElementEventPtr
typedef std::shared_ptr< RecipeElementGroup >	RecipeElementGroupPtr
typedef std::shared_ptr< RecipeElementSimple >	RecipeElementSimplePtr
typedef std::shared_ptr< ValueCondition >	ValueConditionPtr
typedef std::shared_ptr< SequenceHandler >	SequenceHandlerPtr
typedef std::shared_ptr< ChildStatusParam >	ChildStatusParamPtr
typedef std::shared_ptr< ModifiableStatusParam >	ModifiableStatusParamPtr
typedef std::shared_ptr< ParentStatusParam >	ParentStatusParamPtr
typedef std::shared_ptr< Status >	StatusPtr
typedef std::shared_ptr< StatusParam >	StatusParamPtr

Functions¶

	Name
ELogMode	operator&(ELogMode __a, ELogMode __b)
ELogMode	**[operator
ELogMode	operator^(ELogMode __a, ELogMode __b)
ELogMode	operator~(ELogMode __a)
const ELogMode &	**[operator
const ELogMode &	operator&=(ELogMode & __a, ELogMode __b)
const ELogMode &	operator^=(ELogMode & __a, ELogMode __b)

Types Documentation¶

enum EBoxType¶

Enumerator	Value	Description
S_BOX		Small box
M_BOX		Medium box
L_BOX		Large box
XL_BOX		Extra large box
UNKNOWN		Unknown box type

EBoxType enum defines the device controller types.

Enumerates the different types of device controllers supported by the Inscoper system.

enum EConnectionType¶

Enumerator	Value	Description
ADVANCED_CONNECTION		Other connection types (Analog, TTL, PWM, RS232/UART)
USB_CONNECTION		USB connection
ETHERNET_CONNECTION		Ethernet connection

EConnectionType enum defines the types of device connections.

Enumerates the various methods used to connect devices to the device controller.

enum EConnectorType¶

Enumerator	Value	Description
NONE	0x0000000000000000	No connector
UART	0x0000000000000001	RS232/UART interface
USB_DEV	0x0000000000000002	USB Device interface
AOUT	0x0000000000000004	Analog Output
TTL_IN	0x0000000000000008	TTL Input
TTL_OUT	0x0000000000000010	TTL Output
PWM	0x0000000000000020	Pulse Width Modulation
AIN	0x0000000000000040	Analog Input
RJ45	0x0000000000000080	RJ45 (Ethernet) connector
ILDA	0x0000000000000800	ILDA connector (Laser)

EConnectorType enum defines specific connector interfaces.

Enumerates the connector types available on the device controller, represented as bit flags.

enum EConnectionTypeDesc¶

Enumerator	Value	Description
NONE	EConnectorType::NONE	No connection
UART	EConnectorType::UART	UART/RS232 connection
USB_DEV	EConnectorType::USB_DEV	USB Device connection
AOUT	EConnectorType::AOUT	Analog Output
TTL_IN	EConnectorType::TTL_IN	TTL Input
TTL_OUT	EConnectorType::TTL_OUT	TTL Output
PWM	EConnectorType::PWM	Pulse Width Modulation
AIN	EConnectorType::AIN	Analog Input
RJ45	EConnectorType::RJ45	Ethernet (RJ45)
USB_SERIAL_DRIVER	0x0000000000000100	USB Serial Driver
USB_GENERIC_DRIVER	0x0000000000000200	USB Generic Driver
USB_HID_DRIVER	0x0000000000000400	USB HID Driver
ILDA	EConnectorType::ILDA	ILDA connector
USB_SERIAL	(USB_SERIAL_DRIVER \| USB_DEV)	USB Serial
USB_GENERIC	(USB_GENERIC_DRIVER \| USB_DEV)	USB Generic
USB_HID	(USB_HID_DRIVER \| USB_DEV)	USB HID
USB_DRIVER_MASK	(USB_SERIAL_DRIVER \| USB_GENERIC_DRIVER \| USB_HID_DRIVER)	USB
AOUT_GEN	(AOUT)	Generic Analog Output
SERIAL	(UART \| USB_SERIAL)	Serial connection (UART or USB)
TTL_IN_GEN	(TTL_IN)	Generic TTL Input
TTL_OUT_GEN	(TTL_OUT \| PWM)	Generic TTL Output

EConnectionTypeDesc enum defines types of driver connection descriptors.

Enumerates the various connection types supported by the device controller, including generic I/O types and specific USB driver classes.

enum ESubDeviceType¶

Enumerator	Value	Description
NONE	0	No type
INIT		Initialization
FINISH		De-initialization
DIAG		Diagnostic
USB_CHECK		USB Check
X_AXIS		X-axis position control
Y_AXIS		Y-axis position control
MOVE_AXIS		Axis motion control
FOCUS		Focus control
SHUTTER		Shutter control
OBJECTIVE		Objective changer control
CUBE		Filter cube changer control
FILTER_WHEEL		Filter wheel control
TRIG_EDGE		Trigger edge control
TRIG_LEVEL		Trigger level control
CAM_CHECK_READY		Camera readiness check
MAGNIFICATION		Magnification changer control
PROPERTY		Generic property
CAM_START_CONTINUOUS		Continuous camera acquisition start
CAM_START		Camera acquisition start
CAM_STOP		Camera acquisition stop
CAM_SNAP		Single image snap
CAM_SOFTWARE_TRIG		Software trigger for camera

ESubDeviceType enum defines types of sub-devices.

Enumerates the functional categories of sub-devices within a larger device assembly, such as axes, shutters, filters, and camera controls.

enum EDeviceType¶

Enumerator	Value	Description
GENERIC	0	Other device
CAMERA		Imaging device
XY_STAGE		2D positioning device
STAGE		1D positioning device (e.g. Z stage)
SHUTTER		Shutter device

The EDeviceType enum defines the type of devices, among Micro-Manager and custom devices.

Enumerates the types used to specify devices.

enum EFunctionType¶

Enumerator	Value	Description
SET		Set operation
GET		Get operation
CHECK		Wait operation for value to be set

EFunctionType enum defines the types of operations for sub-device functions.

Enumerates the fundamental operations that can be performed: setting a value, getting a value, or waiting for value to be applied.

enum EParamType¶

Enumerator	Value	Description
UINT8		Unsigned 8-bit integer
INT8		Signed 8-bit integer
UINT16		Unsigned 16-bit integer
INT16		Signed 16-bit integer
UINT32		Unsigned 32-bit integer
INT32		Signed 32-bit integer
FLOAT		Single-precision floating point
DOUBLE		Double-precision floating point
UINT64		Unsigned 64-bit integer
INT64		Signed 64-bit integer
STRING		String
RAW		Raw binary data

EParamType enum defines data types.

Enumerates the supported data types.

enum EFunctionStatus¶

Enumerator	Value	Description
AVAILABLE		Function is available
UNAVAILABLE		Function is unavailable
UNKNOWN		Status is unknown

EFunctionStatus enum defines the status of a function.

Indicates whether a specific device function is available for use, unavailable, or in an unknown state.

enum ESubDeviceStatus¶

Enumerator	Value	Description
UNKNOWN		State is unknown
AVAILABLE		Sub-device is fully available
UNAVAILABLE		Sub-device is unavailable
PARTIALLY_AVAILABLE		Sub-device is partially available (not all functions available)

ESubDeviceStatus enum defines the state of a sub-device.

Represents the current state of a sub-device, such as available, unavailable, or partially available (i.e. not all functions are available).

enum EDriverType¶

Enumerator	Value	Description
MICRO_MANAGER	0	Micro-Manager driver
INSCOPER_BOX		Inscoper Box (device controller) driver
CUSTOM_DRIVER		Custom driver
NONE		No driver

EDriverType enum defines the driver type.

Enumerates the supported driver implementations for controlling hardware, including Micro-Manager, Inscoper Box (device controller), and custom drivers.

enum EPixelType¶

Enumerator	Value	Description
GREY_8_BITS		8-bit grayscale
GREY_11_BITS		11-bit grayscale
GREY_12_BITS		12-bit grayscale
GREY_14_BITS		14-bit grayscale
GREY_16_BITS		16-bit grayscale
GREY_32_BITS		32-bit grayscale
GREY_FLOAT_32_BITS		32-bit floating-point grayscale
GREY_FLOAT_64_BITS		64-bit floating-point grayscale
RGB_8_BITS		8-bit RGB color
BGR_8_BITS		8-bit BGR color
RGB_16_BITS		16-bit RGB color
BGR_16_BITS		16-bit BGR color
UNKNOWN		Unknown pixel type

EPixelType enum defines the pixel formats.

Enumerates the pixel data types for an image, including grayscale and color formats with different bit depths.

enum ERecipeElementType¶

Enumerator	Value	Description
SIMPLE		Simple recipe element (action)
GROUP		Group of elements
EVENT		Event recipe element (e.g. user interaction check)

ERecipeElementType enum defines the types of recipe elements.

Enumerates the different types of elements that can compose a recipe, including simple actions, groups of actions, and events.

enum ESequencePreparationStatus¶

Enumerator	Value	Description
CREATING		Sequence is being created
LOADING		Sequence is being loaded
CANCELLED		Preparation was cancelled

ESequencePreparationStatus enum defines the progress state of a sequence preparation.

Indicates the current phase of a sequence being prepared.

enum EOperation¶

Enumerator	Value	Description
OFFSET		Addition offset
MULTIPLICATION		Multiplication factor

EOperation enum defines mathematical operations for child status parameters.

Specifies a mathematical operation to link two status parameter values.

enum ELogLevel¶

Enumerator	Value	Description
LOG_ALL	0	Log all messages
LOG_TRACE		Trace messages
LOG_DEBUG		Debug messages
LOG_INFO		Information messages
LOG_WARN		Warning messages
LOG_ERROR		Error messages
LOG_FATAL		Fatal error messages
LOG_OFF		No messages

ELogLevel enum defines the severity levels for logging.

enum ELogMode¶

Enumerator	Value	Description
FILE	0x01	Output logs to a file
CONSOLE	0x02	Output logs to the console
LISTENER	0x04	Send logs to registered listeners
ALL	FILE \| CONSOLE \| LISTENER	Output to all available destinations

ELogMode enum defines the output destinations for logs.

This enum can be used as bit flags to combine multiple output modes.

typedef AdvancedConnectionConfigPtr¶

typedef std::shared_ptr<AdvancedConnectionConfig> Inscoper::AdvancedConnectionConfigPtr;

typedef ConfigPtr¶

typedef std::shared_ptr<Config> Inscoper::ConfigPtr;

Smart pointer for Config type

typedef ConnectionConfigPtr¶

typedef std::shared_ptr<ConnectionConfig> Inscoper::ConnectionConfigPtr;

Shared pointer for ConnectionConfig type

typedef CustomDriverConfigPtr¶

typedef std::shared_ptr<CustomDriverConfig> Inscoper::CustomDriverConfigPtr;

Shared pointer for CustomDriverConfig type

typedef DeviceConfigPtr¶

typedef std::shared_ptr<DeviceConfig> Inscoper::DeviceConfigPtr;

Shared pointer for DeviceConfig type

typedef DriverConfigPtr¶

typedef std::shared_ptr<DriverConfig> Inscoper::DriverConfigPtr;

Shared pointer for DriverConfig type

typedef EthernetConnectionConfigPtr¶

typedef std::shared_ptr<EthernetConnectionConfig> Inscoper::EthernetConnectionConfigPtr;

typedef InscoperBoxDriverConfigPtr¶

typedef std::shared_ptr<InscoperBoxDriverConfig> Inscoper::InscoperBoxDriverConfigPtr;

Shared pointer for InscoperBoxDriverConfig type

typedef MicroManagerDriverConfigPtr¶

typedef std::shared_ptr<MicroManagerDriverConfig> Inscoper::MicroManagerDriverConfigPtr;

Shared pointer for MicroManagerDriverConfig type

typedef ParamConfigPtr¶

typedef std::shared_ptr<ParamConfig> Inscoper::ParamConfigPtr;

Shared pointer for ParamConfig type

typedef SubDeviceConfigPtr¶

typedef std::shared_ptr<SubDeviceConfig> Inscoper::SubDeviceConfigPtr;

Shared pointer for SubDeviceConfig type

typedef USBConnectionConfigPtr¶

typedef std::shared_ptr<USBConnectionConfig> Inscoper::USBConnectionConfigPtr;

typedef ConnectionDescriptionPtr¶

typedef std::shared_ptr<ConnectionDescription> Inscoper::ConnectionDescriptionPtr;

Shared pointer for ConnectionDescription type

typedef CustomDriverDescriptionPtr¶

typedef std::shared_ptr<CustomDriverDescription> Inscoper::CustomDriverDescriptionPtr;

Shared pointer for CustomDriverDescription type

typedef DeviceDescriptionPtr¶

typedef std::shared_ptr<DeviceDescription> Inscoper::DeviceDescriptionPtr;

Shared pointer for DeviceDescription type

typedef DriverDescriptionPtr¶

typedef std::shared_ptr<DriverDescription> Inscoper::DriverDescriptionPtr;

Shared pointer for DriverDescription type

typedef ExternalDriverDescriptionPtr¶

typedef std::shared_ptr<ExternalDriverDescription> Inscoper::ExternalDriverDescriptionPtr;

Shared pointer for ExternalDriverDescription type

typedef FunctionDescriptionPtr¶

typedef std::shared_ptr<FunctionDescription> Inscoper::FunctionDescriptionPtr;

Shared pointer for FunctionDescription type

typedef InscoperBoxDriverDescriptionPtr¶

typedef std::shared_ptr<InscoperBoxDriverDescription> Inscoper::InscoperBoxDriverDescriptionPtr;

Shared pointer for InscoperBoxDriverDescription type

typedef MicroManagerDriverDescriptionPtr¶

typedef std::shared_ptr<MicroManagerDriverDescription> Inscoper::MicroManagerDriverDescriptionPtr;

Shared pointer for MicroManagerDriverDescription type

typedef ParamDescriptionPtr¶

typedef std::shared_ptr<ParamDescription> Inscoper::ParamDescriptionPtr;

Shared pointer for ParamDescription type

typedef SubDeviceDescriptionPtr¶

typedef std::shared_ptr<SubDeviceDescription> Inscoper::SubDeviceDescriptionPtr;

Shared pointer for SubDeviceDescription type

typedef SystemPtr¶

typedef std::shared_ptr<AbstractSystem> Inscoper::SystemPtr;

typedef CameraPtr¶

typedef std::shared_ptr<Camera> Inscoper::CameraPtr;

Shared pointer for Camera type

typedef ShutterPtr¶

typedef std::shared_ptr<Shutter> Inscoper::ShutterPtr;

Shared pointer for Shutter type

typedef StagePtr¶

typedef std::shared_ptr<Stage> Inscoper::StagePtr;

Shared pointer for Stage type

typedef XYStagePtr¶

typedef std::shared_ptr<XYStage> Inscoper::XYStagePtr;

Shared pointer for XYStage type

typedef ConstraintPtr¶

typedef std::shared_ptr<Constraint> Inscoper::ConstraintPtr;

Shared pointer for Constraint type

typedef DiagResultsPtr¶

typedef std::shared_ptr<DiagResults> Inscoper::DiagResultsPtr;

Shared pointer for DiagResults type

typedef DimensionPtr¶

typedef std::shared_ptr<Dimension> Inscoper::DimensionPtr;

Shared pointer for Dimension type

typedef DimensionParamPtr¶

typedef std::shared_ptr<DimensionParam> Inscoper::DimensionParamPtr;

Shared pointer for DimensionParam type

typedef ImagePtr¶

typedef std::shared_ptr<Image> Inscoper::ImagePtr;

Shared pointer for Image type

typedef MetadataPtr¶

typedef std::shared_ptr<Metadata> Inscoper::MetadataPtr;

typedef RecipePtr¶

typedef std::shared_ptr<Recipe> Inscoper::RecipePtr;

Shared pointer for Recipe type

typedef RecipeElementPtr¶

typedef std::shared_ptr<RecipeElement> Inscoper::RecipeElementPtr;

Shared pointer for RecipeElement type

typedef RecipeElementEventPtr¶

typedef std::shared_ptr<RecipeElementEvent> Inscoper::RecipeElementEventPtr;

typedef RecipeElementGroupPtr¶

typedef std::shared_ptr<RecipeElementGroup> Inscoper::RecipeElementGroupPtr;

typedef RecipeElementSimplePtr¶

typedef std::shared_ptr<RecipeElementSimple> Inscoper::RecipeElementSimplePtr;

Shared pointer for RecipeElementSimple type

typedef ValueConditionPtr¶

typedef std::shared_ptr<ValueCondition> Inscoper::ValueConditionPtr;

Shared pointer for ValueCondition type

typedef SequenceHandlerPtr¶

typedef std::shared_ptr<SequenceHandler> Inscoper::SequenceHandlerPtr;

Shared pointer for SequenceHandler type

typedef ChildStatusParamPtr¶

typedef std::shared_ptr<ChildStatusParam> Inscoper::ChildStatusParamPtr;

Shared pointer for ChildStatusParam type

typedef ModifiableStatusParamPtr¶

typedef std::shared_ptr<ModifiableStatusParam> Inscoper::ModifiableStatusParamPtr;

Shared pointer for ModifiableStatusParam type

typedef ParentStatusParamPtr¶

typedef std::shared_ptr<ParentStatusParam> Inscoper::ParentStatusParamPtr;

Shared pointer for ParentStatusParam type

typedef StatusPtr¶

typedef std::shared_ptr<Status> Inscoper::StatusPtr;

Shared pointer for Status type

typedef StatusParamPtr¶

typedef std::shared_ptr<StatusParam> Inscoper::StatusParamPtr;

Shared pointer for StatusParam type

Functions Documentation¶

function operator&¶

inline ELogMode operator&(
    ELogMode __a,
    ELogMode __b
)

function operator|¶

inline ELogMode operator|(
    ELogMode __a,
    ELogMode __b
)

function operator^¶

inline ELogMode operator^(
    ELogMode __a,
    ELogMode __b
)

function operator~¶

inline ELogMode operator~(
    ELogMode __a
)

function operator|=¶

inline const ELogMode & operator|=(
    ELogMode & __a,
    ELogMode __b
)

function operator&=¶

inline const ELogMode & operator&=(
    ELogMode & __a,
    ELogMode __b
)

function operator^=¶

inline const ELogMode & operator^=(
    ELogMode & __a,
    ELogMode __b
)

Updated on 2026-04-02 at 10:55:35 +0200